package com.github.wisdom.common.github.modules.util;

import com.alibaba.fastjson.JSONObject;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class QueryEntityTools {

	/**
	 * 将实体转换成Map
	 * 
	 * @param bean
	 * @return
	 */
	public static Map<String, Object> beanToMap(Object bean) {
		Class<?> type = bean.getClass();
		Map<String, Object> returnMap = new HashMap<String, Object>();
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(type);
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for (int i = 0; i < propertyDescriptors.length; i++) {
				PropertyDescriptor descriptor = propertyDescriptors[i];
				String propertyName = descriptor.getName();
				if (!propertyName.equals("class")) {
					Method readMethod = descriptor.getReadMethod();
					if (readMethod != null) {
						Object result = readMethod.invoke(bean, new Object[0]);
						if (result != null) {
							returnMap.put(propertyName, result);
						} else {
							returnMap.put(propertyName, "");
						}
					}
				}
			}
		} catch (Exception e) {
			returnMap.put("error", e.getMessage());
		}
		return returnMap;
	}

	/**
	 * 将实体转换成Json
	 * 
	 * @param bean
	 * @return
	 */
	public static JSONObject beanToJson(Object bean) {
		Class<?> type = bean.getClass();
		JSONObject json = new JSONObject();
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(type);
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for (int i = 0; i < propertyDescriptors.length; i++) {
				PropertyDescriptor descriptor = propertyDescriptors[i];
				String propertyName = descriptor.getName();
				if (!propertyName.equals("class")) {
					Method readMethod = descriptor.getReadMethod();
					if (readMethod != null) {
						Object result = readMethod.invoke(bean, new Object[0]);
						if (result != null) {
							json.put(propertyName, result);
						} else {
							json.put(propertyName, "");
						}
					}
				}
			}
		} catch (Exception e) {
			json.put("error", e.getMessage());
		}
		return json;
	}

	/**
	 * 将map转换成Json
	 * 
	 * @param bean
	 * @return
	 */
	public static JSONObject mapToJson(Map<String, ? extends Object> map) {
		JSONObject json = new JSONObject();
		for (String key : map.keySet()) {
			json.put(key, map.get(key));
		}
		return json;
	}

	/**
	 * 将map转换成实体
	 * 
	 * @param map
	 * @param bean
	 * @return
	 */
	public static <T, K, v> T mapToBean(Map<K, v> map, Class<T> bean) {
		T t = null;
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(bean);
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			t = bean.newInstance();
			for (PropertyDescriptor property : propertyDescriptors) {
				String key = property.getName();
				if (map.containsKey(key)) {
					Object value = map.get(key);
					Method setter = property.getWriteMethod();
					if (checkType(value, property.getPropertyType())) {
						setter.invoke(t, value);
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return t;
	}

	private static boolean checkType(Object a, Class<?> b) {
		Class<? extends Object> oc = a.getClass();
		if (oc == b || oc.getSuperclass() == b || checkInterfaces(oc.getInterfaces(), b)) {
			return true;
		} else {
			return false;
		}
	}

	private static boolean checkInterfaces(Class<?>[] cArray, Class<?> b) {
		boolean tag = false;
		for (Class<?> c : cArray) {
			if (c == b) {
				tag = true;
				break;
			}
		}
		return tag;
	}

	/**
	 * Map List To Bean List
	 * 
	 * @param map
	 * @param bean
	 * @return
	 */
	public static <T, k, v> List<T> mapListToBeanList(List<Map<k, v>> listMap, Class<T> bean) {
		List<T> beanList = new ArrayList<T>(listMap.size());
		for (Map<k, v> map : listMap) {
			T t = null;
			try {
				BeanInfo beanInfo = Introspector.getBeanInfo(bean);
				PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
				t = bean.newInstance();
				for (PropertyDescriptor property : propertyDescriptors) {
					String key = property.getName();
					if (map.containsKey(key)) {
						Object value = map.get(key);
						Method setter = property.getWriteMethod();
						setter.invoke(t, value);
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			beanList.add(t);
		}

		return beanList;
	}

	/**
	 * 将实体转换成Map
	 * 将key按驼峰规则转换成下划线分隔(字母大写)
	 * @param bean
	 * @return
	 */
	public static Map<String, Object> beanToColumnMap(Object bean) {
		Class<?> type = bean.getClass();
		Map<String, Object> returnMap = new HashMap<String, Object>();
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(type);
			PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
			for (int i = 0; i < propertyDescriptors.length; i++) {
				PropertyDescriptor descriptor = propertyDescriptors[i];
				String propertyName = descriptor.getName();
				if (!propertyName.equals("class")) {
					Method readMethod = descriptor.getReadMethod();
					Object result = readMethod.invoke(bean, new Object[0]);
					if (result != null && !result.equals("")) {
						returnMap.put(camelToUnderline(propertyName), result);
					}
				}
			}
		} catch (Exception e) {
			e.getMessage();
			// returnMap.put("error", e.getMessage());
			// returnMap = null;
		}
		return returnMap;
	}

	/**
	 * 将camel Map转成Column Map
	 * 
	 * @param bean
	 * @return
	 */
	public static Map<String, Object> camelMapToColumnMap(Map<String, Object> beanMap) {
		Map<String, Object> returnMap = new HashMap<String, Object>();
		try {
			for (String key : beanMap.keySet()) {
				returnMap.put(camelToUnderline(key), beanMap.get(key));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return returnMap;
	}

	/**
	 * 字符串下划线转驼峰
	 * 
	 * @param line
	 * @return
	 */
	public static String underlineToCamel(String line) {
		if (line == null || "".equals(line)) {
			return "";
		}
		StringBuffer sb = new StringBuffer();
		Pattern pattern = Pattern.compile("([A-Za-z\\d]+)(_)?");
		Matcher matcher = pattern.matcher(line);
		while (matcher.find()) {
			String word = matcher.group();
			Character c = word.charAt(0);
			sb.append(matcher.start() == 0 ? Character.toLowerCase(c) : Character.toUpperCase(c));
			int index = word.lastIndexOf('_');
			if (index > 0) {
				sb.append(word.substring(1, index).toLowerCase());
			} else {
				sb.append(word.substring(1).toLowerCase());
			}
		}
		return sb.toString();
	}

	/**
	 * 字符串驼峰转下划线
	 * 
	 * @param line
	 * @return
	 */
	public static String camelToUnderline(String line) {
		if (line == null || "".equals(line)) {
			return "";
		}
		Character c = line.charAt(0);
		String f = line.substring(1);
		line = String.valueOf(c).toUpperCase().concat(f);
		StringBuffer sb = new StringBuffer();
		Pattern pattern = Pattern.compile("[A-Z]([a-z\\d]+)?");
		Matcher matcher = pattern.matcher(line);
		while (matcher.find()) {
			String word = matcher.group();
			sb.append(word.toUpperCase());
			sb.append(matcher.end() == line.length() ? "" : "_");
		}
		return sb.toString();
	}

}
